#ifndef __THREAD_HPP__
#define __THREAD_HPP__

// 包含必要的头文件
#include <iostream>     // 标准输入输出流
#include <string>       // 字符串处理
#include <unistd.h>     // Unix标准函数接口
#include <functional>   // 函数对象和绑定器
#include <pthread.h>    // POSIX线程库

// 定义线程模块命名空间
namespace ThreadModule
{
    // 模板函数类型定义，表示线程要执行的任务函数类型
    // 函数接收类型T的引用作为参数，无返回值
    template<typename T>
    using func_t = std::function<void(T&)>;
    // typedef std::function<void(const T&)> func_t;

    // 线程类模板，T为线程处理的数据类型
    template<typename T>
    class Thread
    {
    public:
        // 执行线程任务的函数，内部调用存储的任务函数
        void Excute()
        {
            _func(_data);
        }
    public:
        // 构造函数，初始化线程对象
        // func: 线程要执行的函数
        // data: 线程要处理的数据
        // name: 线程名称，默认为"none-name"
        Thread(func_t<T> func, T &data, const std::string &name="none-name")
            : _func(func), _data(data), _threadname(name), _stop(true)
        {}
        // 线程入口函数，由pthread_create调用
        // 注意：这是一个静态函数，通过args参数接收Thread对象指针
        static void *threadroutine(void *args) // 类成员函数，形参是有this指针的！！
        {
            // 将void*类型参数转换为Thread*类型
            Thread<T> *self = static_cast<Thread<T> *>(args);
            // 调用Thread对象的Excute方法执行任务
            self->Excute();
            return nullptr;
        }
        // 启动线程函数
        // 创建线程并设置线程状态
        // 返回：创建成功返回true，失败返回false
        bool Start()
        {
            // 创建线程，传入this指针作为线程函数参数
            // 注意：如果Thread对象存储在vector中，vector扩容可能导致this指针失效
            int n = pthread_create(&_tid, nullptr, threadroutine, this);
            if(!n)
            {
                _stop = false;  // 设置线程状态为运行
                return true;
            }
            else
            {
                return false;
            }
        }
        // 线程分离函数
        // 调用后，线程结束时自动释放资源，无需Join
        void Detach()
        {
            if(!_stop)  // 只有线程在运行时才分离
            {
                pthread_detach(_tid);
            }
        }
        // 等待线程结束
        // 主线程调用此函数会阻塞，直到此线程执行完毕
        void Join()
        {
            if(!_stop)  // 只有线程在运行时才等待
            {
                pthread_join(_tid, nullptr);
            }
        }
        // 获取线程名称
        std::string name()
        {
            return _threadname;
        }
        // 停止线程
        // 注意：仅设置状态标记，不会真正终止线程执行
        void Stop()
        {
            _stop = true;
        }
        // 析构函数
        // 注意：不会自动回收线程资源，如需回收应先调用Join或Detach
        ~Thread() {}

    private:
        pthread_t _tid;           // 线程ID
        std::string _threadname;  // 线程名称
        T &_data;  // 为了让所有的线程访问同一个全局变量
        func_t<T> _func;          // 线程要执行的任务函数
        bool _stop;               // 线程状态标志：true表示停止，false表示运行
    };
} // namespace ThreadModule

#endif